{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "478f9994",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "数据形状: (1080, 3)\n",
      "\n",
      "前5行数据:\n",
      "   客户编号                                                 评论  评价\n",
      "0     1  是iPhone8 XR正品，按键屏幕反应蛮快的很灵活，屏幕6.0的不算很大，刚刚好，这款面容...   1\n",
      "1     2  外形外观：外光非常漂亮，黑色的非常大气。适合男士拥有。屏幕音效：刚开机就下载了一个QQ音乐试...   1\n",
      "2     3  从苹果4s，到6s，再到xr，就是喜欢苹果的手感和风格，视频流畅，图片清晰，纠结了好久买哪个...   1\n",
      "3     4  主要是手感，太沉了，比苹果6，沉一倍，厚太多了，看中双卡双待机，刚买回来用，待机时间还不错，...   1\n",
      "4     5  外形外观：红色超级好看，送妈妈的。屏幕音效：音效还可以，也什么特别的，屏幕看着也挺舒服。拍照...   1\n",
      "\n",
      "评价分布:\n",
      "评价\n",
      "1    600\n",
      "0    480\n",
      "Name: count, dtype: int64\n",
      "正面评价比例: 55.56%\n",
      "\n",
      "============================================================\n",
      "中文分词处理\n",
      "============================================================\n",
      "第一条评论分词示例:\n",
      "原始评论: 是iPhone8 XR正品，按键屏幕反应蛮快的很灵活，屏幕6.0的不算很大，刚刚好，这款面容识别开锁比指纹方便多了，内外的整体看起来很美观，整机子不算是很厚感，像素高比较清晰，双卡双待，续航强，跟8plus差价300元，还是选XR款好，性能不错，处理器、芯片也是最新一代\n",
      "分词结果: 是 iPhone8   XR 正品 ， 按键 屏幕 反应 蛮快 的 很 灵活 ， 屏幕 6.0 的 不算 很大 ， 刚刚 好 ， 这 款 面容 识别 开锁 比 指纹 方便 多 了 ， 内外 的 整体 看起来 很 美观 ， 整机 子 不算 是 很厚感 ， 像素 高 比较 清晰 ， 双卡 双待 ， 续航 强 ， 跟 8plus 差价 300 元 ， 还是 选 XR 款好 ， 性能 不错 ， 处理器 、 芯片 也 是 最新 一代\n",
      "\n",
      "正在进行中文分词...\n",
      "前3条评论的分词结果:\n",
      "1. 是 iPhone8   XR 正品 ， 按键 屏幕 反应 蛮快 的 很 灵活 ， 屏幕 6.0 的 不算 很大 ， 刚刚 好 ， 这 款 面容 识别 开锁 比 指纹 方便 多 了 ， 内外 的 整体 看起来 很 美观 ， 整机 子 不算 是 很厚感 ， 像素 高 比较 清晰 ， 双卡 双待 ， 续航 强 ， 跟 8plus 差价 300 元 ， 还是 选 XR 款好 ， 性能 不错 ， 处理器 、 芯片 也 是 最新 一代\n",
      "2. 外形 外观 ： 外光 非常 漂亮 ， 黑色 的 非常 大气 。 适合 男士 拥有 。 屏幕 音效 ： 刚 开机 就 下载 了 一个 QQ 音乐 试 了 一下 。   音效 还是 非常 不错 的 。 拍照 效果 ： 拍照 很 清晰 ， 照亮 你 脸上 的 痘痘 。 运行 速度 ： 运行 速度 就 不用说 了 。   一个 字快 。 待机时间 ： 待机 很 不错 。 用 一段时间 再 来 评价 。 其他 特色 ： 个人感觉 比 Ｘ 好 。   可能 是因为 上手 的 手感 比较 好 吧 ， 总之 还是 值得 入手 的\n",
      "3. 从 苹果 4s ， 到 6s ， 再 到 xr ， 就是 喜欢 苹果 的 手感 和 风格 ， 视频 流畅 ， 图片 清晰 ， 纠结 了 好久 买 哪个 颜色 ， 白色 干净 ， 同事 买 的 黄色 ， 感觉 也 很 好看 ， 蓝色 ， 珊瑚 我 也 喜欢 ， 最终 还是 选择 比较 适合 女生 的 珊瑚 色 ， 实物 比 图片 更 漂亮 ， 超级 喜欢 ， 运行 速度 快 ， 全屏 显示 ， 体积小 了 ， 可 显示 区域 变得 了 ， 很棒 。\n",
      "\n",
      "============================================================\n",
      "文本向量化\n",
      "============================================================\n",
      "\n",
      "使用 词频统计 进行向量化...\n",
      "词袋大小: 4075\n",
      "特征矩阵形状: (1080, 4075)\n",
      "前10个特征词: ['00' '0022' '0k' '10' '100' '1000' '10050' '1080' '1080p' '10w']\n",
      "\n",
      "使用 TF-IDF 进行向量化...\n",
      "词袋大小: 4075\n",
      "特征矩阵形状: (1080, 4075)\n",
      "前10个特征词: ['00' '0022' '0k' '10' '100' '1000' '10050' '1080' '1080p' '10w']\n",
      "\n",
      "目标变量分布:\n",
      "评价\n",
      "1    600\n",
      "0    480\n",
      "Name: count, dtype: int64\n",
      "\n",
      "训练集形状: (864, 4075)\n",
      "测试集形状: (216, 4075)\n",
      "训练集正面评价比例: 55.56%\n",
      "测试集正面评价比例: 55.56%\n",
      "\n",
      "============================================================\n",
      "情感分析模型比较\n",
      "============================================================\n",
      "\n",
      "=== 逻辑回归 ===\n",
      "训练中... 完成! 训练时间: 0.01秒\n",
      "准确率: 0.9769\n",
      "AUC分数: 0.9945\n",
      "\n",
      "=== 多项式朴素贝叶斯 ===\n",
      "训练中... 完成! 训练时间: 0.00秒\n",
      "准确率: 0.8194\n",
      "AUC分数: 0.9892\n",
      "\n",
      "=== 伯努利朴素贝叶斯 ===\n",
      "训练中... 完成! 训练时间: 0.00秒\n",
      "准确率: 0.9815\n",
      "AUC分数: 0.9990\n",
      "\n",
      "=== SVM线性 ===\n",
      "训练中... 完成! 训练时间: 0.27秒\n",
      "准确率: 0.9815\n",
      "AUC分数: 0.9955\n",
      "\n",
      "=== 随机森林 ===\n",
      "训练中... 完成! 训练时间: 0.35秒\n",
      "准确率: 0.9907\n",
      "AUC分数: 0.9996\n",
      "\n",
      "=== 决策树 ===\n",
      "训练中... 完成! 训练时间: 0.02秒\n",
      "准确率: 0.9306\n",
      "AUC分数: 0.9281\n",
      "\n",
      "=== K近邻 ===\n",
      "训练中... 完成! 训练时间: 0.00秒\n",
      "准确率: 0.4444\n",
      "AUC分数: 0.5250\n",
      "\n",
      "=== AdaBoost ===\n",
      "训练中... 完成! 训练时间: 0.29秒\n",
      "准确率: 0.9491\n",
      "AUC分数: 0.9905\n",
      "\n",
      "=== XGBoost ===\n",
      "训练中... 完成! 训练时间: 0.13秒\n",
      "准确率: 0.9722\n",
      "AUC分数: 0.9964\n",
      "\n",
      "=== LightGBM ===\n",
      "训练中... [LightGBM] [Info] Number of positive: 480, number of negative: 384\n",
      "[LightGBM] [Info] Auto-choosing row-wise multi-threading, the overhead of testing was 0.001442 seconds.\n",
      "You can set `force_row_wise=true` to remove the overhead.\n",
      "And if memory is not enough, you can set `force_col_wise=true`.\n",
      "[LightGBM] [Info] Total Bins 3047\n",
      "[LightGBM] [Info] Number of data points in the train set: 864, number of used features: 168\n",
      "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.555556 -> initscore=0.223144\n",
      "[LightGBM] [Info] Start training from score 0.223144\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
      "完成! 训练时间: 0.07秒\n",
      "准确率: 0.9815\n",
      "AUC分数: 0.9968\n",
      "\n",
      "============================================================\n",
      "模型性能比较汇总\n",
      "============================================================\n",
      "         模型       准确率     AUC分数   训练时间(秒)\n",
      "4      随机森林  0.990741  0.999566  0.345333\n",
      "2  伯努利朴素贝叶斯  0.981481  0.998958  0.000998\n",
      "3     SVM线性  0.981481  0.995486  0.265036\n",
      "9  LightGBM  0.981481  0.996788  0.066509\n",
      "0      逻辑回归  0.976852  0.994531  0.006769\n",
      "8   XGBoost  0.972222  0.996441  0.127775\n",
      "7  AdaBoost  0.949074  0.990495  0.289048\n",
      "5       决策树  0.930556  0.928125  0.019778\n",
      "1  多项式朴素贝叶斯  0.819444  0.989236  0.000999\n",
      "6       K近邻  0.444444  0.525000  0.001007\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\pppython\\Lib\\site-packages\\sklearn\\utils\\validation.py:2749: UserWarning: X does not have valid feature names, but LGBMClassifier was fitted with feature names\n",
      "  warnings.warn(\n",
      "D:\\pppython\\Lib\\site-packages\\sklearn\\utils\\validation.py:2749: UserWarning: X does not have valid feature names, but LGBMClassifier was fitted with feature names\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x1200 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "============================================================\n",
      "最佳模型: 随机森林\n",
      "最佳准确率: 0.9907\n",
      "============================================================\n",
      "\n",
      "详细分类报告:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "          负面       0.99      0.99      0.99        96\n",
      "          正面       0.99      0.99      0.99       120\n",
      "\n",
      "    accuracy                           0.99       216\n",
      "   macro avg       0.99      0.99      0.99       216\n",
      "weighted avg       0.99      0.99      0.99       216\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "============================================================\n",
      "关键词重要性分析\n",
      "============================================================\n",
      "最重要的20个特征词汇:\n",
      "    词汇       重要性\n",
      "0   流畅  0.035873\n",
      "1   非常  0.028467\n",
      "2   喜欢  0.027441\n",
      "3   苹果  0.026421\n",
      "4   屏幕  0.026307\n",
      "5   速度  0.023808\n",
      "6   续航  0.022909\n",
      "7   不错  0.019683\n",
      "8   好看  0.019114\n",
      "9   很快  0.017401\n",
      "10  xr  0.016951\n",
      "11  感觉  0.015280\n",
      "12  电池  0.015163\n",
      "13  手感  0.015121\n",
      "14  运行  0.014651\n",
      "15  没有  0.014403\n",
      "16  拍照  0.013685\n",
      "17  系统  0.013103\n",
      "18  手机  0.012396\n",
      "19  还是  0.012046\n",
      "\n",
      "============================================================\n",
      "预测结果示例分析\n",
      "============================================================\n",
      "随机样本预测结果:\n",
      "\n",
      "样本 1 [✓ 正确]:\n",
      "  实际标签: 正面\n",
      "  预测标签: 正面\n",
      "  评论内容: 这个颜色艳丽，非常喜欢，本来看图片想买黄色，到实体店还是觉得这个珊瑚好看，惊艳，从6sp直接升级到xr，屏幕变大了，手机尺寸变小了，面部解锁功能，可以活动筋骨脖子，好玩\n",
      "\n",
      "样本 2 [✓ 正确]:\n",
      "  实际标签: 正面\n",
      "  预测标签: 正面\n",
      "  评论内容: 虽然没有安卓系统那么方便，但是第一次使用iOS感觉确实很不错，很多功能都很方便iOS的系统处理很优秀，不会像安卓那么笨重，希望这台手机能挺好几年吧\n",
      "\n",
      "样本 3 [✓ 正确]:\n",
      "  实际标签: 正面\n",
      "  预测标签: 正面\n",
      "  评论内容: 购买之前还有些担心遇见差评里的那些情况，结果很愉快的一次购物，东西很完美，没有什么意外磕碰和损伤，开机后检查外观没有磕碰等瑕疵。真机正品，插电脑爱思显示机子是19.4.28日郑州富士康生产，日期很新，电池充电次数是0！蓝色很正，屏幕显示超过之前用的8p尽管参数上什么分辨率低，这点大家可以完全放心了，苹果就是苹果，厉害啊，还是那句话，真香！用了就知道。\n",
      "\n",
      "样本 4 [✓ 正确]:\n",
      "  实际标签: 正面\n",
      "  预测标签: 正面\n",
      "  评论内容: 真香机果然名不虚传，作为本年度最佳水果机的代表作，包揽了最佳lcd、最佳续航、双卡双待、多彩外壳，并且使用了目前最强的A12，并且保证了出色的性价比，无论是日常使用还是游戏体验绝对是目前的顶级队列，续航亦是如此。\n",
      "\n",
      "样本 5 [✓ 正确]:\n",
      "  实际标签: 负面\n",
      "  预测标签: 负面\n",
      "  评论内容: 11月1日买的，刚几天就领券减600？跟我闹呢？维权一定要竞争到底！\n",
      "\n",
      "样本 6 [✓ 正确]:\n",
      "  实际标签: 负面\n",
      "  预测标签: 负面\n",
      "  评论内容: #\n",
      "\n",
      "样本 7 [✓ 正确]:\n",
      "  实际标签: 正面\n",
      "  预测标签: 正面\n",
      "  评论内容: 大黑边丝毫没影响，主要习惯问题，从三星note系列转过来，三星旗舰屏幕已经够叼了，然而发现xr的屏幕效果也很棒，真的不是参数决定的，并且，重度使用眼睛也没特别难受的感觉，还有，这个系统，真的不摆了，特意使用了一段时间才过来评论，真的很不错\n",
      "\n",
      "样本 8 [✓ 正确]:\n",
      "  实际标签: 正面\n",
      "  预测标签: 正面\n",
      "  评论内容: 使了半个多月了吧！很好用的，性价比也很好，电量真的很牛，一天下来还剩很多电量，玩游戏也不卡，就是冲电慢一点，黑边不算太大，能接受的，很不错\n",
      "\n",
      "============================================================\n",
      "不同向量化方法比较\n",
      "============================================================\n",
      "词频统计 准确率: 0.9907\n",
      "TF-IDF 准确率: 0.9769\n",
      "\n",
      "============================================================\n",
      "新评论预测示例\n",
      "============================================================\n",
      "新评论情感预测:\n",
      "  '这个产品非常好用，质量很棒！' → 负面 (置信度: 0.500)\n",
      "  '垃圾产品，完全不好用，浪费钱' → 负面 (置信度: 0.870)\n",
      "  '一般般吧，没什么特别的感觉' → 负面 (置信度: 0.710)\n",
      "  '外观漂亮但功能不太实用' → 负面 (置信度: 0.720)\n",
      "  '性价比很高，推荐购买' → 负面 (置信度: 0.710)\n",
      "\n",
      "============================================================\n",
      "情感分析总结与建议\n",
      "============================================================\n",
      "\n",
      "    🎯 最佳模型: 随机森林\n",
      "    📊 准确率: 0.9907\n",
      "    📈 AUC分数: 0.9996\n",
      "    ⏱️ 训练时间: 0.35秒\n",
      "\n",
      "    💡 改进建议:\n",
      "    1. 增加更多标注数据提高模型性能\n",
      "    2. 尝试深度学习模型(如LSTM、BERT)\n",
      "    3. 加入情感词典增强特征工程\n",
      "    4. 考虑评论文本的长度和复杂度\n",
      "    5. 定期更新模型以适应语言变化\n",
      "\n",
      "    🚀 应用场景:\n",
      "    - 产品评价自动分类\n",
      "    - 客户反馈情感分析\n",
      "    - 社交媒体舆情监控\n",
      "    - 市场调研数据分析\n",
      "    \n",
      "\n",
      "情感分析完成!\n"
     ]
    }
   ],
   "source": [
    "# 设置中文字体支持\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['font.sans-serif'] = ['SimHei', 'Microsoft YaHei', 'DejaVu Sans']\n",
    "plt.rcParams['axes.unicode_minus'] = False\n",
    "\n",
    "import pandas as pd\n",
    "df = pd.read_excel(\"D:\\贺之恒的python\\pppython\\python商业数据分析\\@Python大数据分析与机器学习商业案例实战\\第16章 神经网络模型\\源代码汇总_PyCharm格式\\产品评价.xlsx\")\n",
    "print(\"数据形状:\", df.shape)\n",
    "print(\"\\n前5行数据:\")\n",
    "print(df.head())\n",
    "\n",
    "# 检查评价分布\n",
    "print(\"\\n评价分布:\")\n",
    "print(df['评价'].value_counts())\n",
    "print(f\"正面评价比例: {df['评价'].mean():.2%}\")\n",
    "\n",
    "# 1.中文分词\n",
    "import jieba\n",
    "\n",
    "print(\"\\n\" + \"=\"*60)\n",
    "print(\"中文分词处理\")\n",
    "print(\"=\"*60)\n",
    "\n",
    "# 显示分词示例\n",
    "print(\"第一条评论分词示例:\")\n",
    "print(\"原始评论:\", df.iloc[0]['评论'])\n",
    "word_example = jieba.cut(df.iloc[0]['评论'])\n",
    "result_example = ' '.join(word_example)\n",
    "print(\"分词结果:\", result_example)\n",
    "\n",
    "# 对所有评论进行分词\n",
    "print(\"\\n正在进行中文分词...\")\n",
    "words = []\n",
    "for i, row in df.iterrows():\n",
    "    word = jieba.cut(row['评论'])\n",
    "    result = ' '.join(word)\n",
    "    words.append(result)\n",
    "\n",
    "print(\"前3条评论的分词结果:\")\n",
    "for i in range(3):\n",
    "    print(f\"{i+1}. {words[i]}\")\n",
    "\n",
    "# 2.文本向量化\n",
    "print(\"\\n\" + \"=\"*60)\n",
    "print(\"文本向量化\")\n",
    "print(\"=\"*60)\n",
    "\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "\n",
    "# 使用两种不同的向量化方法\n",
    "vectorizers = {\n",
    "    '词频统计': CountVectorizer(),\n",
    "    'TF-IDF': TfidfVectorizer()\n",
    "}\n",
    "\n",
    "X_vectors = {}\n",
    "feature_names_dict = {}\n",
    "\n",
    "for vec_name, vectorizer in vectorizers.items():\n",
    "    print(f\"\\n使用 {vec_name} 进行向量化...\")\n",
    "    X = vectorizer.fit_transform(words)\n",
    "    X_vectors[vec_name] = X\n",
    "    \n",
    "    # 获取特征名称\n",
    "    feature_names = vectorizer.get_feature_names_out()\n",
    "    feature_names_dict[vec_name] = feature_names\n",
    "    print(f\"词袋大小: {len(feature_names)}\")\n",
    "    print(f\"特征矩阵形状: {X.shape}\")\n",
    "    \n",
    "    # 显示前10个特征词\n",
    "    print(f\"前10个特征词: {feature_names[:10]}\")\n",
    "\n",
    "# 3.准备目标变量\n",
    "y = df['评价']\n",
    "print(f\"\\n目标变量分布:\")\n",
    "print(y.value_counts())\n",
    "\n",
    "# 4.划分训练集和测试集\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# 使用TF-IDF向量化结果（通常效果更好）\n",
    "X = X_vectors['TF-IDF']\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n",
    "\n",
    "print(f\"\\n训练集形状: {X_train.shape}\")\n",
    "print(f\"测试集形状: {X_test.shape}\")\n",
    "print(f\"训练集正面评价比例: {y_train.mean():.2%}\")\n",
    "print(f\"测试集正面评价比例: {y_test.mean():.2%}\")\n",
    "\n",
    "# 5.导入多种分类模型\n",
    "print(\"\\n\" + \"=\"*60)\n",
    "print(\"情感分析模型比较\")\n",
    "print(\"=\"*60)\n",
    "\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, AdaBoostClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.naive_bayes import MultinomialNB, BernoulliNB\n",
    "from sklearn.metrics import accuracy_score, classification_report, confusion_matrix, roc_auc_score\n",
    "import numpy as np\n",
    "\n",
    "# 检查是否安装了高级模型\n",
    "try:\n",
    "    from xgboost import XGBClassifier\n",
    "    XGB_AVAILABLE = True\n",
    "except ImportError:\n",
    "    print(\"XGBoost未安装，跳过XGBoost模型\")\n",
    "    XGB_AVAILABLE = False\n",
    "\n",
    "try:\n",
    "    from lightgbm import LGBMClassifier\n",
    "    LGBM_AVAILABLE = True\n",
    "except ImportError:\n",
    "    print(\"LightGBM未安装，跳过LightGBM模型\")\n",
    "    LGBM_AVAILABLE = False\n",
    "\n",
    "# 创建模型字典（特别适合文本分类的模型）\n",
    "models = {\n",
    "    '逻辑回归': LogisticRegression(random_state=42, max_iter=1000),\n",
    "    '多项式朴素贝叶斯': MultinomialNB(),\n",
    "    '伯努利朴素贝叶斯': BernoulliNB(),\n",
    "    'SVM线性': SVC(kernel='linear', probability=True, random_state=42),\n",
    "    '随机森林': RandomForestClassifier(n_estimators=100, random_state=42),\n",
    "    '决策树': DecisionTreeClassifier(random_state=42),\n",
    "    'K近邻': KNeighborsClassifier(),\n",
    "    'AdaBoost': AdaBoostClassifier(random_state=42),\n",
    "}\n",
    "\n",
    "# 添加可选的模型\n",
    "if XGB_AVAILABLE:\n",
    "    models['XGBoost'] = XGBClassifier(random_state=42)\n",
    "\n",
    "if LGBM_AVAILABLE:\n",
    "    models['LightGBM'] = LGBMClassifier(random_state=42)\n",
    "\n",
    "# 存储结果\n",
    "results = {}\n",
    "\n",
    "# 6.训练和评估各个模型\n",
    "import time\n",
    "\n",
    "for model_name, model in models.items():\n",
    "    print(f\"\\n=== {model_name} ===\")\n",
    "    \n",
    "    try:\n",
    "        # 模型训练（带时间统计）\n",
    "        start_time = time.time()\n",
    "        print(\"训练中...\", end=' ')\n",
    "        model.fit(X_train, y_train)\n",
    "        training_time = time.time() - start_time\n",
    "        print(f\"完成! 训练时间: {training_time:.2f}秒\")\n",
    "        \n",
    "        # 模型预测\n",
    "        y_pred = model.predict(X_test)\n",
    "        y_pred_proba = model.predict_proba(X_test)[:, 1] if hasattr(model, 'predict_proba') else None\n",
    "        \n",
    "        # 评估指标\n",
    "        accuracy = accuracy_score(y_test, y_pred)\n",
    "        \n",
    "        # 计算AUC（如果模型支持概率预测）\n",
    "        auc_score = roc_auc_score(y_test, y_pred_proba) if y_pred_proba is not None else None\n",
    "        \n",
    "        print(f\"准确率: {accuracy:.4f}\")\n",
    "        if auc_score is not None:\n",
    "            print(f\"AUC分数: {auc_score:.4f}\")\n",
    "        \n",
    "        # 存储结果\n",
    "        results[model_name] = {\n",
    "            'model': model,\n",
    "            'accuracy': accuracy,\n",
    "            'auc': auc_score,\n",
    "            'training_time': training_time,\n",
    "            'y_pred': y_pred,\n",
    "            'y_pred_proba': y_pred_proba\n",
    "        }\n",
    "        \n",
    "    except Exception as e:\n",
    "        print(f\"训练失败: {e}\")\n",
    "        continue\n",
    "\n",
    "# 7.比较模型性能\n",
    "print(\"\\n\" + \"=\"*60)\n",
    "print(\"模型性能比较汇总\")\n",
    "print(\"=\"*60)\n",
    "\n",
    "if results:\n",
    "    performance_df = pd.DataFrame({\n",
    "        '模型': list(results.keys()),\n",
    "        '准确率': [result['accuracy'] for result in results.values()],\n",
    "        'AUC分数': [result['auc'] if result['auc'] is not None else -1 for result in results.values()],\n",
    "        '训练时间(秒)': [result['training_time'] for result in results.values()]\n",
    "    }).sort_values('准确率', ascending=False)\n",
    "    \n",
    "    print(performance_df)\n",
    "    \n",
    "    # 8.可视化模型性能比较\n",
    "    fig, axes = plt.subplots(2, 2, figsize=(16, 12))\n",
    "    \n",
    "    # 准确率比较\n",
    "    bars1 = axes[0,0].bar(performance_df['模型'], performance_df['准确率'], \n",
    "                         color=plt.cm.Set3(np.arange(len(performance_df))), alpha=0.8)\n",
    "    axes[0,0].set_title('各模型准确率比较', fontsize=14, fontweight='bold')\n",
    "    axes[0,0].set_ylabel('准确率', fontsize=12)\n",
    "    axes[0,0].tick_params(axis='x', rotation=45)\n",
    "    axes[0,0].set_ylim(0, 1.0)\n",
    "    axes[0,0].grid(True, alpha=0.3, axis='y')\n",
    "    \n",
    "    # 在柱状图上添加数值\n",
    "    for bar in bars1:\n",
    "        height = bar.get_height()\n",
    "        axes[0,0].text(bar.get_x() + bar.get_width()/2., height + 0.01,\n",
    "                      f'{height:.3f}', ha='center', va='bottom', fontweight='bold')\n",
    "    \n",
    "    # AUC分数比较（只显示有AUC分数的模型）\n",
    "    auc_data = performance_df[performance_df['AUC分数'] > 0]\n",
    "    if len(auc_data) > 0:\n",
    "        bars2 = axes[0,1].bar(auc_data['模型'], auc_data['AUC分数'], \n",
    "                             color=plt.cm.Pastel1(np.arange(len(auc_data))), alpha=0.8)\n",
    "        axes[0,1].set_title('各模型AUC分数比较', fontsize=14, fontweight='bold')\n",
    "        axes[0,1].set_ylabel('AUC分数', fontsize=12)\n",
    "        axes[0,1].tick_params(axis='x', rotation=45)\n",
    "        axes[0,1].set_ylim(0, 1.0)\n",
    "        axes[0,1].grid(True, alpha=0.3, axis='y')\n",
    "        \n",
    "        for bar in bars2:\n",
    "            height = bar.get_height()\n",
    "            axes[0,1].text(bar.get_x() + bar.get_width()/2., height + 0.01,\n",
    "                          f'{height:.3f}', ha='center', va='bottom', fontweight='bold')\n",
    "    \n",
    "    # 训练时间比较\n",
    "    bars3 = axes[1,0].bar(performance_df['模型'], performance_df['训练时间(秒)'], \n",
    "                         color=plt.cm.Set2(np.arange(len(performance_df))), alpha=0.8)\n",
    "    axes[1,0].set_title('各模型训练时间比较', fontsize=14, fontweight='bold')\n",
    "    axes[1,0].set_ylabel('训练时间(秒)', fontsize=12)\n",
    "    axes[1,0].tick_params(axis='x', rotation=45)\n",
    "    axes[1,0].grid(True, alpha=0.3, axis='y')\n",
    "    \n",
    "    for bar in bars3:\n",
    "        height = bar.get_height()\n",
    "        axes[1,0].text(bar.get_x() + bar.get_width()/2., height + 0.01,\n",
    "                      f'{height:.1f}s', ha='center', va='bottom', fontweight='bold')\n",
    "    \n",
    "    # 预测值与实际值对比（最佳模型）\n",
    "    best_model_name = performance_df.iloc[0]['模型']\n",
    "    best_y_pred = results[best_model_name]['y_pred']\n",
    "    \n",
    "    # 计算正确和错误的预测\n",
    "    correct_mask = (best_y_pred == y_test)\n",
    "    axes[1,1].pie([correct_mask.sum(), len(correct_mask) - correct_mask.sum()], \n",
    "                  labels=['正确预测', '错误预测'], autopct='%1.1f%%', \n",
    "                  colors=['lightgreen', 'lightcoral'])\n",
    "    axes[1,1].set_title(f'{best_model_name} - 预测准确率分布', fontsize=14, fontweight='bold')\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    \n",
    "    # 9.选择最佳模型并进行详细分析\n",
    "    best_model_name = performance_df.iloc[0]['模型']\n",
    "    best_model = results[best_model_name]['model']\n",
    "    best_accuracy = performance_df.iloc[0]['准确率']\n",
    "    \n",
    "    print(f\"\\n\" + \"=\"*60)\n",
    "    print(f\"最佳模型: {best_model_name}\")\n",
    "    print(f\"最佳准确率: {best_accuracy:.4f}\")\n",
    "    print(\"=\"*60)\n",
    "    \n",
    "    # 使用最佳模型进行详细预测分析\n",
    "    best_y_pred = results[best_model_name]['y_pred']\n",
    "    \n",
    "    print(\"\\n详细分类报告:\")\n",
    "    print(classification_report(y_test, best_y_pred, target_names=['负面', '正面']))\n",
    "    \n",
    "    # 10.可视化混淆矩阵\n",
    "    cm = confusion_matrix(y_test, best_y_pred)\n",
    "    \n",
    "    plt.figure(figsize=(8, 6))\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)\n",
    "    plt.title(f'{best_model_name} - 混淆矩阵\\n准确率: {best_accuracy:.3f}', \n",
    "              fontsize=14, fontweight='bold')\n",
    "    plt.colorbar()\n",
    "    \n",
    "    tick_marks = np.arange(2)\n",
    "    plt.xticks(tick_marks, ['预测负面', '预测正面'])\n",
    "    plt.yticks(tick_marks, ['实际负面', '实际正面'])\n",
    "    plt.xlabel('预测标签')\n",
    "    plt.ylabel('真实标签')\n",
    "    \n",
    "    # 在图中添加数字\n",
    "    thresh = cm.max() / 2.\n",
    "    for i in range(cm.shape[0]):\n",
    "        for j in range(cm.shape[1]):\n",
    "            plt.text(j, i, format(cm[i, j], 'd'),\n",
    "                    horizontalalignment=\"center\",\n",
    "                    color=\"white\" if cm[i, j] > thresh else \"black\",\n",
    "                    fontweight='bold')\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    \n",
    "    # 11.关键词分析（对于可解释的模型）\n",
    "    print(\"\\n\" + \"=\"*60)\n",
    "    print(\"关键词重要性分析\")\n",
    "    print(\"=\"*60)\n",
    "\n",
    "    # 对于逻辑回归和朴素贝叶斯等模型，可以分析特征重要性\n",
    "    if hasattr(best_model, 'coef_'):\n",
    "        # 逻辑回归系数\n",
    "        feature_importance = best_model.coef_[0]\n",
    "        feature_names = feature_names_dict['TF-IDF']\n",
    "        \n",
    "        # 获取最重要的正面和负面词汇\n",
    "        top_positive_indices = feature_importance.argsort()[-10:][::-1]\n",
    "        top_negative_indices = feature_importance.argsort()[:10]\n",
    "        \n",
    "        print(\"最重要的正面词汇（倾向于正面评价）:\")\n",
    "        for idx in top_positive_indices:\n",
    "            print(f\"  {feature_names[idx]}: {feature_importance[idx]:.4f}\")\n",
    "        \n",
    "        print(\"\\n最重要的负面词汇（倾向于负面评价）:\")\n",
    "        for idx in top_negative_indices:\n",
    "            print(f\"  {feature_names[idx]}: {feature_importance[idx]:.4f}\")\n",
    "        \n",
    "        # 可视化关键词重要性\n",
    "        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))\n",
    "        \n",
    "        # 正面词汇\n",
    "        positive_words = [feature_names[i] for i in top_positive_indices]\n",
    "        positive_scores = [feature_importance[i] for i in top_positive_indices]\n",
    "        ax1.barh(range(len(positive_words)), positive_scores, color='lightgreen')\n",
    "        ax1.set_yticks(range(len(positive_words)))\n",
    "        ax1.set_yticklabels(positive_words)\n",
    "        ax1.set_xlabel('重要性分数')\n",
    "        ax1.set_title('正面评价关键词', fontweight='bold')\n",
    "        ax1.grid(True, alpha=0.3, axis='x')\n",
    "        \n",
    "        # 负面词汇\n",
    "        negative_words = [feature_names[i] for i in top_negative_indices]\n",
    "        negative_scores = [feature_importance[i] for i in top_negative_indices]\n",
    "        ax2.barh(range(len(negative_words)), negative_scores, color='lightcoral')\n",
    "        ax2.set_yticks(range(len(negative_words)))\n",
    "        ax2.set_yticklabels(negative_words)\n",
    "        ax2.set_xlabel('重要性分数')\n",
    "        ax2.set_title('负面评价关键词', fontweight='bold')\n",
    "        ax2.grid(True, alpha=0.3, axis='x')\n",
    "        \n",
    "        plt.suptitle('情感分析关键词重要性', fontsize=16, fontweight='bold')\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "    elif hasattr(best_model, 'feature_importances_'):\n",
    "        # 树模型的特征重要性\n",
    "        feature_importance = best_model.feature_importances_\n",
    "        feature_names = feature_names_dict['TF-IDF']\n",
    "        \n",
    "        # 获取最重要的特征\n",
    "        top_indices = feature_importance.argsort()[-20:][::-1]\n",
    "        \n",
    "        print(\"最重要的20个特征词汇:\")\n",
    "        top_features_df = pd.DataFrame({\n",
    "            '词汇': [feature_names[i] for i in top_indices],\n",
    "            '重要性': [feature_importance[i] for i in top_indices]\n",
    "        })\n",
    "        print(top_features_df)\n",
    "\n",
    "    # 12.预测结果示例分析\n",
    "    print(\"\\n\" + \"=\"*60)\n",
    "    print(\"预测结果示例分析\")\n",
    "    print(\"=\"*60)\n",
    "\n",
    "    # 修复：使用y_test的长度而不是X_test的长度\n",
    "    n_samples = min(8, len(y_test))\n",
    "    indices = np.random.choice(len(y_test), n_samples, replace=False)\n",
    "\n",
    "    print(\"随机样本预测结果:\")\n",
    "    for i, idx in enumerate(indices):\n",
    "        actual_label = y_test.iloc[idx]\n",
    "        predicted_label = best_y_pred[idx]\n",
    "        \n",
    "        # 获取原始评论文本\n",
    "        # 由于我们使用了train_test_split，需要找到对应的原始索引\n",
    "        test_indices = y_test.index\n",
    "        original_index = test_indices[idx]\n",
    "        original_text = df.loc[original_index, '评论']\n",
    "        \n",
    "        status = \"✓ 正确\" if actual_label == predicted_label else \"✗ 错误\"\n",
    "        \n",
    "        print(f\"\\n样本 {i+1} [{status}]:\")\n",
    "        print(f\"  实际标签: {'正面' if actual_label == 1 else '负面'}\")\n",
    "        print(f\"  预测标签: {'正面' if predicted_label == 1 else '负面'}\")\n",
    "        print(f\"  评论内容: {original_text}\")\n",
    "\n",
    "    # 13.不同向量化方法比较\n",
    "    print(\"\\n\" + \"=\"*60)\n",
    "    print(\"不同向量化方法比较\")\n",
    "    print(\"=\"*60)\n",
    "\n",
    "    # 比较词频统计和TF-IDF的效果\n",
    "    if len(X_vectors) > 1:\n",
    "        comparison_results = {}\n",
    "        \n",
    "        for vec_name, X_vec in X_vectors.items():\n",
    "            # 重新划分训练测试集\n",
    "            X_train_vec, X_test_vec, y_train_vec, y_test_vec = train_test_split(\n",
    "                X_vec, y, test_size=0.2, random_state=42, stratify=y)\n",
    "            \n",
    "            # 使用逻辑回归进行基准测试\n",
    "            lr_model = LogisticRegression(random_state=42, max_iter=1000)\n",
    "            lr_model.fit(X_train_vec, y_train_vec)\n",
    "            accuracy = accuracy_score(y_test_vec, lr_model.predict(X_test_vec))\n",
    "            \n",
    "            comparison_results[vec_name] = accuracy\n",
    "            print(f\"{vec_name} 准确率: {accuracy:.4f}\")\n",
    "\n",
    "    # 14.模型部署示例 - 新评论预测\n",
    "    print(\"\\n\" + \"=\"*60)\n",
    "    print(\"新评论预测示例\")\n",
    "    print(\"=\"*60)\n",
    "\n",
    "    # 准备预测新评论的函数\n",
    "    def predict_sentiment(text, model, vectorizer):\n",
    "        \"\"\"预测单条评论的情感\"\"\"\n",
    "        # 分词\n",
    "        words = ' '.join(jieba.cut(text))\n",
    "        # 向量化\n",
    "        X_new = vectorizer.transform([words])\n",
    "        # 预测\n",
    "        prediction = model.predict(X_new)[0]\n",
    "        probability = model.predict_proba(X_new)[0] if hasattr(model, 'predict_proba') else None\n",
    "        \n",
    "        return prediction, probability\n",
    "\n",
    "    # 测试新评论\n",
    "    test_comments = [\n",
    "        \"这个产品非常好用，质量很棒！\",\n",
    "        \"垃圾产品，完全不好用，浪费钱\",\n",
    "        \"一般般吧，没什么特别的感觉\",\n",
    "        \"外观漂亮但功能不太实用\",\n",
    "        \"性价比很高，推荐购买\"\n",
    "    ]\n",
    "\n",
    "    print(\"新评论情感预测:\")\n",
    "    for comment in test_comments:\n",
    "        prediction, probability = predict_sentiment(comment, best_model, vectorizers['TF-IDF'])\n",
    "        sentiment = \"正面\" if prediction == 1 else \"负面\"\n",
    "        prob_text = f\" (置信度: {max(probability):.3f})\" if probability is not None else \"\"\n",
    "        \n",
    "        print(f\"  '{comment}' → {sentiment}{prob_text}\")\n",
    "\n",
    "    # 15.性能总结\n",
    "    print(\"\\n\" + \"=\"*60)\n",
    "    print(\"情感分析总结与建议\")\n",
    "    print(\"=\"*60)\n",
    "\n",
    "    # 修复：将复杂的条件表达式分开处理\n",
    "    auc_score = performance_df.iloc[0]['AUC分数']\n",
    "    auc_display = f\"{auc_score:.4f}\" if auc_score > 0 else 'N/A'\n",
    "    \n",
    "    print(f\"\"\"\n",
    "    🎯 最佳模型: {best_model_name}\n",
    "    📊 准确率: {best_accuracy:.4f}\n",
    "    📈 AUC分数: {auc_display}\n",
    "    ⏱️ 训练时间: {performance_df.iloc[0]['训练时间(秒)']:.2f}秒\n",
    "\n",
    "    💡 改进建议:\n",
    "    1. 增加更多标注数据提高模型性能\n",
    "    2. 尝试深度学习模型(如LSTM、BERT)\n",
    "    3. 加入情感词典增强特征工程\n",
    "    4. 考虑评论文本的长度和复杂度\n",
    "    5. 定期更新模型以适应语言变化\n",
    "\n",
    "    🚀 应用场景:\n",
    "    - 产品评价自动分类\n",
    "    - 客户反馈情感分析\n",
    "    - 社交媒体舆情监控\n",
    "    - 市场调研数据分析\n",
    "    \"\"\")\n",
    "\n",
    "else:\n",
    "    print(\"没有模型成功训练，请检查数据和模型配置\")\n",
    "\n",
    "print(\"\\n情感分析完成!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef676c14",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
